const app = getApp()
const pagePermission = require('../../utils/pagepermission.js')

Page({
  data: {
    form: {
      order_id: '',
      product_name: '',
      product_model: '',
      total_quantity: '',
      planned_start_time: '',
      planned_end_time: '',
      plan_name: '',
      plan_code: '',
      description: ''
    },
    orders: [],
    products: [],
    models: [],
    orderIndex: -1,
    productIndex: -1,
    selectedProductQuantity: 0, // 选中产品的订单数量
    availableQuantity: 0, // 可用数量（订单数量-已分配数量-主动报工数量-生产计划数量）
    allocatedQuantity: 0, // 已分配数量
    reportedQuantity: 0, // 主动报工数量
    plannedQuantity: 0, // 生产计划数量
    loading: false
  },

  onLoad(options) {
    // 页面权限检查
    if (!pagePermission.requirePagePermission('pages/create-production-plan/create-production-plan')) {
      return
    }
    
    if (options.orderId) {
      this.setData({
        'form.order_id': options.orderId
      })
    }
    this.loadOrders()
    this.loadProducts()
  },

  // 加载订单列表
  loadOrders() {
    app.request({
      url: '/getOrders',
      method: 'GET',
      data: { limit: 100 }
    }).then(res => {
      if (res.code === 1) {
        const orders = res.data.list || []
        this.setData({
          orders: orders.map(order => ({
            id: order.id,
            name: order.order_name || order.order_no
          }))
        })
      }
    }).catch(err => {
      console.error('加载订单失败:', err)
    })
  },

  // 加载产品列表
  loadProducts() {
    app.request({
      url: '/getProductList',
      method: 'GET',
      data: { limit: 100 }
    }).then(res => {
      if (res.code === 1) {
        this.setData({
          products: res.data.list || []
        })
      }
    }).catch(err => {
      console.error('加载产品失败:', err)
    })
  },

  // 订单选择
  onOrderChange(e) {
    const orderIndex = parseInt(e.detail.value)
    const order = this.data.orders[orderIndex]
    if (order) {
      console.log('onOrderChange - 选择的订单:', order)
      
      this.setData({
        orderIndex: orderIndex,
        'form.order_id': order.id
      })
      
      console.log('onOrderChange - 设置form.order_id为:', order.id)
      this.loadOrderProducts(order.id)
    }
  },

  // 加载订单产品
  loadOrderProducts(orderId) {
    if (!orderId) return
    
    console.log('loadOrderProducts - 加载订单产品，orderId:', orderId)
    
    app.request({
      url: '/getOrderProducts',
      method: 'GET',
      data: { order_id: orderId }
    }).then(res => {
      if (res.code === 1) {
        const products = res.data || []
        console.log('loadOrderProducts - 获取到的产品列表:', products)
        this.setData({
          products: products
        })
      }
    }).catch(err => {
      console.error('加载订单产品失败:', err)
    })
  },

  // 产品选择
  onProductChange(e) {
    const productIndex = parseInt(e.detail.value)
    const product = this.data.products[productIndex]
    if (product) {
      console.log('onProductChange - 选择的产品:', product)
      console.log('onProductChange - 当前form.order_id:', this.data.form.order_id)
      
      this.setData({
        productIndex: productIndex,
        'form.product_name': product.product_name,
        'form.product_model': product.model_name,
        selectedProductQuantity: product.quantity || 0
      })
      // 获取该产品的可用数量
      this.loadProductAvailableQuantity(product.model_id)
    }
  },

  // 获取产品可用数量
  loadProductAvailableQuantity(modelId) {
    if (!modelId) return
    
    console.log('loadProductAvailableQuantity调用参数:', {
      modelId: modelId,
      order_id: this.data.form.order_id
    })
    
    app.request({
      url: '/getProductAvailableQuantity',
      method: 'GET',
      data: { 
        model_id: modelId,
        order_id: this.data.form.order_id
      }
    }).then(res => {
      if (res.code === 1) {
        const data = res.data || {}
        this.setData({
          availableQuantity: data.available_quantity || 0,
          allocatedQuantity: data.allocated_quantity || 0,
          reportedQuantity: data.reported_quantity || 0,
          plannedQuantity: data.planned_quantity || 0
        })
      }
    }).catch(err => {
      console.error('获取产品可用数量失败:', err)
      
      // 如果是Token过期错误，不显示错误信息，因为app.js已经处理了
      if (err.code === 401) {
        console.log('Token过期，跳过数量获取')
        return
      }
      
      // 如果是其他错误，显示提示并设置默认值
      wx.showToast({
        title: '获取数量信息失败',
        icon: 'none',
        duration: 1500
      })
      
      // 如果接口失败，至少显示订单数量
      this.setData({
        availableQuantity: this.data.selectedProductQuantity,
        allocatedQuantity: 0,
        reportedQuantity: 0
      })
    })
  },

  // 输入框变化
  onInputChange(e) {
    const field = e.currentTarget.dataset.field
    const value = e.detail.value
    this.setData({
      [`form.${field}`]: value
    })
    
    // 如果是数量输入，检查是否超过可用数量
    if (field === 'total_quantity' && value) {
      const quantity = parseInt(value)
      const available = this.data.availableQuantity
      if (quantity > available) {
        wx.showToast({
          title: `计划数量不能超过可用数量${available}`,
          icon: 'none',
          duration: 2000
        })
      }
    }
  },

  // 日期选择
  onDateChange(e) {
    const field = e.currentTarget.dataset.field
    const value = e.detail.value
    this.setData({
      [`form.${field}`]: value
    })
  },

  // 提交表单
  submitForm() {
    // 验证必填字段
    if (!this.data.form.order_id) {
      wx.showToast({
        title: '请选择订单',
        icon: 'none'
      })
      return
    }

    if (!this.data.form.product_name) {
      wx.showToast({
        title: '请选择产品',
        icon: 'none'
      })
      return
    }

    if (!this.data.form.total_quantity) {
      wx.showToast({
        title: '请输入计划数量',
        icon: 'none'
      })
      return
    }

    // 检查计划数量是否超过可用数量
    const planQuantity = parseInt(this.data.form.total_quantity)
    const availableQuantity = this.data.availableQuantity
    if (planQuantity > availableQuantity) {
      wx.showToast({
        title: `计划数量不能超过可用数量${availableQuantity}`,
        icon: 'none'
      })
      return
    }

    if (!this.data.form.planned_start_time) {
      wx.showToast({
        title: '请选择计划开始时间',
        icon: 'none'
      })
      return
    }

    if (!this.data.form.planned_end_time) {
      wx.showToast({
        title: '请选择计划结束时间',
        icon: 'none'
      })
      return
    }

    this.setData({ loading: true })

    app.request({
      url: '/createProductionPlan',
      method: 'POST',
      data: this.data.form
    }).then(res => {
      this.setData({ loading: false })
      if (res.code === 1) {
        wx.showToast({
          title: '创建成功',
          icon: 'success'
        })
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      } else {
        wx.showToast({
          title: res.msg || '创建失败',
          icon: 'none'
        })
      }
    }).catch(err => {
      this.setData({ loading: false })
      console.error('创建生产计划失败:', err)
      wx.showToast({
        title: '创建失败',
        icon: 'none'
      })
    })
  }
})
